Introduction

Ce cours vise à vous fournir les compétences nécessaires pour créer des visualisations de données percutantes et informatives en utilisant la bibliothèque ggplot2 de R. Que vous soyez un analyste de données, un scientifique de données, ou simplement quelqu’un d’intéressé par la data science, ce cours vous aidera à transformer vos données en insights visuels compréhensibles.

Pourquoi la Visualisation de Données?

La visualisation de données est essentielle dans le monde d’aujourd’hui.

  • Communication Efficace: La visualisation aide à communiquer les résultats et les insights de manière claire et efficace.
  • Exploration de Données: Elle joue un rôle clé dans l’exploration de données, permettant de découvrir des tendances, des motifs et des anomalies.
  • Prise de Décision Basée sur les Données: Les visualisations rendent les données compréhensibles, facilitant ainsi la prise de décisions éclairées.

Qu’est-ce que ggplot2?

ggplot2: Un Outil Puissant pour la Visualisation de Données

  • Partie de l’écosystème R: ggplot2 est une bibliothèque R largement utilisée pour la création de visualisations de données de haute qualité.
  • Basé sur la Grammaire de la Graphique: ggplot2 utilise les concepts de la “grammaire de la graphique”, une approche systématique pour construire des graphiques en couches.
  • Personnalisable et Flexible: Il offre une grande flexibilité pour personnaliser les graphiques, ce qui le rend adapté pour une large gamme de scénarios.

Objectifs du Cours

À la fin de ce cours, vous serez capable de :

  • Comprendre les principes fondamentaux de la visualisation de données.
  • Utiliser ggplot2 pour créer une variété de graphiques.
  • Personnaliser vos graphiques pour les rendre plus informatifs et visuellement attrayants.
  • Appliquer les meilleures pratiques en matière de design de graphiques.
Illustration du langage R par DALL-E
Illustration du langage R par DALL-E

Organisation

Contenu du Cours : - Démonstrations - Exercices

Ressources

Création de Graphiques de Base

Chaque graphique utilise ggplot()pour initialiser l’objet ggplot et spécifie la source de données (data) et l’aesthetic mapping (aes) qui définit quelles variables sont utilisées sur les axes x et y, ainsi que d’autres paramètres esthétiques tels que la couleur, la taille, etc.

barplot

library(tidyverse)
## -- Attaching core tidyverse packages ------------------------ tidyverse 2.0.0 --
## v dplyr     1.1.4     v readr     2.1.4
## v forcats   1.0.0     v stringr   1.5.1
## v ggplot2   3.4.4     v tibble    3.2.1
## v lubridate 1.9.3     v tidyr     1.3.0
## v purrr     1.0.2     
## -- Conflicts ------------------------------------------ tidyverse_conflicts() --
## x dplyr::filter() masks stats::filter()
## x dplyr::lag()    masks stats::lag()
## i Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors
head(diamonds)
## # A tibble: 6 x 10
##   carat cut       color clarity depth table price     x     y     z
##   <dbl> <ord>     <ord> <ord>   <dbl> <dbl> <int> <dbl> <dbl> <dbl>
## 1  0.23 Ideal     E     SI2      61.5    55   326  3.95  3.98  2.43
## 2  0.21 Premium   E     SI1      59.8    61   326  3.89  3.84  2.31
## 3  0.23 Good      E     VS1      56.9    65   327  4.05  4.07  2.31
## 4  0.29 Premium   I     VS2      62.4    58   334  4.2   4.23  2.63
## 5  0.31 Good      J     SI2      63.3    58   335  4.34  4.35  2.75
## 6  0.24 Very Good J     VVS2     62.8    57   336  3.94  3.96  2.48
ggplot(data = diamonds, aes(x = cut)) +
  geom_bar()

histogrammes

ggplot(data = diamonds, aes(x = carat)) +
  geom_histogram(binwidth = 0.1)

scatterplot et jitter

ggplot(data = diamonds,  aes(x = carat, y = price)) +
  geom_point()

ggplot(data = diamonds,  aes(x = carat, y = price)) +
  geom_jitter()

boxplot

data <- data.frame(
  Group = rep(c("A", "B", "C"), each = 100),
  Value = rnorm(300)
)

# Créez un boxplot en utilisant ggplot2
ggplot(data, aes(x = Group, y = Value)) +
  geom_boxplot()

lines

diamonds %>%
  group_by(carat) %>%
  summarise(mean_price = mean(price)) %>% 
  ggplot(aes(x = carat, y = mean_price)) +
  geom_line()

Personnalisation des graphiques : couleurs, légendes, et titres.

ggplot2 est un système de création de graphiques pour R, basé sur la grammaire des graphiques. Il permet de créer des graphiques complexes en assemblant des éléments de base de manière intuitive.

# Barplot des Diamants par Qualité de Coupe
?scale_fill_brewer()
## starting httpd help server ... done
ggplot(data = diamonds, aes(x = cut, fill = cut)) +
  geom_bar() + 
  labs(title = "Distribution des Diamants par Qualité de Coupe",
       x = "Qualité de la Coupe",
       y = "Nombre de Diamants") +
  scale_fill_brewer(palette = "Set1", guide = 'none') +
  theme_minimal()

ggplot(data = diamonds, aes(x = carat, y = price, color = clarity)) +
  geom_point() +
  labs(title = "Relation entre le Poids et le Prix des Diamants",
       x = "Carats",
       y = "Prix (USD)",
       color = "Clarté") +
  scale_color_brewer(type = "seq", palette = "Blues") +
  theme_classic() +
  theme(
    axis.title = element_text(colour = "blue", face = "bold"),
    plot.title = element_text(colour = "blue", face = "bold"),
    plot.subtitle = element_text(colour = "blue", face = "bold"))

# Utilisation de `theme_set`
theme_set(theme_bw() + theme(
  axis.title = element_text(colour = "blue", face = "bold"),
  plot.title = element_text(colour = "blue", face = "bold"),
  plot.subtitle = element_text(colour = "blue", face = "bold")))
# Différence entre Setting et Mapping

# gauche : setting
ggplot(mpg, aes(x = displ, y = hwy)) +
  geom_point(shape = 10)

# droite : mapping
ggplot(mpg, aes(x = displ, y = hwy, shape = drv)) +
  geom_point()                                       

#  Plusieurs façons de modifier les couleurs et les thèmes
p <- ggplot(mpg, aes(x = displ, y = hwy)) + 
  geom_point()

p <- p + geom_point(color = "red")  
p <- p +  aes(color = drv)
p <- p + aes(color = cty > 20)    
p + theme_bw()

p + xlim(0, 8) + ylim(0, 40)
## Warning: Removed 3 rows containing missing values (`geom_point()`).
## Removed 3 rows containing missing values (`geom_point()`).

p

ggplot(mpg, aes(x = displ, y = hwy)) +
  geom_point() +
  scale_x_continuous(breaks = seq(0, 10, 1)) +
  scale_y_continuous(labels = scales::comma_format(scale = 1e-4)) +
  theme(axis.text.x = element_text(size = 10, color = "blue"),
        axis.text.y = element_text(size = 12, color = "green"))

Techniques Avancées de Visualisation :

Utilisation de facettes pour des graphiques multi-panneaux avec les données babynames

  • Chargement des bibliothèques :babynames, et viridis utilisées pour les données, et les palettes de couleurs, respectivement.
  • Préparation des données : Sélection des prénoms spécifiques dans le dataset babynames et filtrage par sexe.
  • Création du graphique :
    • ggplot() initialise le graphique.
    • geom_area() crée des graphiques à aire.
    • scale_fill_viridis() applique une palette de couleurs.
    • theme() et theme_ipsum() sont utilisés pour personnaliser l’apparence du graphique.
    • facet_wrap(~name, scale="free_y") divise le graphique en plusieurs panneaux, un pour chaque nom, avec des échelles y libres.

Ce script crée un graphique qui montre la popularité de certains prénoms américains au fil du temps.

library(babynames)
library(viridis)
## Loading required package: viridisLite
# Load dataset from github
data <- read.table("https://raw.githubusercontent.com/holtzy/data_to_viz/master/Example_dataset/3_TwoNumOrdered.csv", header=T)
data$date <- as.Date(data$date)

# Load dataset from github
don <- babynames %>% 
  filter(name %in% c("Ashley", "Amanda", "Mary", "Deborah",
                     "Dorothy", "Betty", "Helen", "Jennifer", "Shirley")) %>%
  filter(sex=="F")

# Plot
don %>%
  ggplot( aes(x=year, y=n, group=name, fill=name)) +
  geom_area() +
  scale_fill_viridis(discrete = TRUE) +
  theme(legend.position="none") +
  ggtitle("Popularity of American names in the previous 30 years") + 
  theme(
    legend.position="none",
    panel.spacing = unit(0, "lines"),
    strip.text.x = element_text(size = 8),
    plot.title = element_text(size=13)
  ) +
  facet_wrap(~name, scale="free_y")

Graphique de l’évolution du prix du bitcoin

  • Chargement et préparation des données : Les données sont chargées d’une source en ligne et la colonne date est convertie au format Date.
  • Création du graphique :
    • ggplot() initialise le graphique.
    • geom_line() et geom_point() sont utilisés pour créer un graphique linéaire avec des points mis en évidence.
    • theme_ipsum() avec base_family = "Arial" applique un thème avec une police standard.
    • ggtitle() ajoute un titre au graphique.

Ce script montre l’évolution récente du prix du bitcoin.

data <- read.table("https://raw.githubusercontent.com/holtzy/data_to_viz/master/Example_dataset/3_TwoNumOrdered.csv", header=T)
data$date <- as.Date(data$date)

# Plot
data %>%
  tail(1000) %>%
  ggplot( aes(x=date, y=value)) +
  geom_line( color="grey") +
  geom_point(shape=21, color="black", fill="#69b3a2", size=6) +
  ggtitle("Evolution of bitcoin price")

Créer une carte avec leaflet

Leaflet est une bibliothèque JavaScript open source très populaire, utilisée pour créer des cartes interactives sur le Web. Bien qu’elle soit principalement basée sur JavaScript, elle peut être utilisée dans le langage de programmation R grâce à un package appelé leaflet pour R. Voici quelques points clés à connaître sur Leaflet dans le contexte de R :

  1. Création de cartes interactives: Leaflet vous permet de créer des cartes interactives que vous pouvez intégrer dans des applications web ou des documents R Markdown. Ces cartes peuvent être personnalisées avec différents styles et fonctionnalités.

  2. Facilité d’utilisation: Même pour les débutants, Leaflet est relativement simple à utiliser en R. Vous pouvez commencer avec quelques lignes de code pour générer une carte de base, puis progressivement ajouter des fonctionnalités plus complexes.

  3. Superpositions et marqueurs: Vous pouvez ajouter des superpositions à vos cartes, comme des marqueurs, des cercles ou des polygones, pour représenter des données géographiques. Ces éléments peuvent être interactifs, affichant des informations supplémentaires lorsque l’utilisateur clique dessus ou passe la souris dessus.

  4. Intégration avec des données spatiales: Leaflet pour R fonctionne bien avec des données spatiales. Vous pouvez utiliser des packages comme sf (simple features) pour manipuler des données géographiques, puis les visualiser avec Leaflet.

  5. Personnalisation: Vous avez la possibilité de personnaliser l’apparence de votre carte avec différents styles de tuiles (par exemple, OpenStreetMap, Mapbox) et d’ajouter des fonctionnalités comme des couches de contrôle, des légendes, et plus encore.

Pour commencer avec Leaflet en R, vous devez d’abord installer et charger le package leaflet. Ensuite, vous pouvez utiliser des fonctions comme leaflet() pour créer une carte et addTiles() pour ajouter des tuiles de fond. De là, vous pouvez explorer d’autres fonctions pour ajouter des marqueurs, des couches, etc.

Voici un exemple de code simple pour créer une carte de base avec Leaflet en R :

library(leaflet)

# Créer une carte de base
leaflet() %>% addTiles()

Voici un exemple de script pour génèrer une carte interactive sur laquelle vous pouvez zoomer et vous déplacer

  1. Installer et charger le package leaflet :
if (!require(leaflet)) {
  install.packages("leaflet")
}
## Loading required package: leaflet
library(leaflet)

Cette partie vérifie d’abord si le package leaflet est installé (require(leaflet)). Si ce n’est pas le cas (!require(leaflet)), il l’installe (install.packages("leaflet")). Ensuite, le package leaflet est chargé en mémoire avec library(leaflet), ce qui permet d’utiliser ses fonctions.

  1. Créer une carte de base :
map <- leaflet() %>% 
  addTiles()  # Ajoute les tuiles de base d'OpenStreetMap

Ici, une carte de base est créée avec leaflet() et des tuiles par défaut (généralement d’OpenStreetMap) sont ajoutées avec addTiles(). Le résultat est stocké dans la variable map.

  1. Ajouter un marqueur :
map <- map %>% 
  addMarkers(lng = -0.09, lat = 51.50, popup = "The marker is placed at London")

Cette ligne ajoute un marqueur sur la carte. Le marqueur est placé à Londres (longitude -0.09, latitude 51.50), et un texte popup s’affiche lorsque vous cliquez sur le marqueur (“The marker is placed at London”).

  1. Changer le fond de carte :
map <- map %>% 
  addProviderTiles(providers$Stamen.TonerLite)

Ici, le style de la carte est changé en utilisant une tuile différente fournie par Stamen.TonerLite, donnant à la carte un aspect visuel différent.

  1. Données pour les marqueurs supplémentaires :

    data <- data.frame(
  lng = c(-0.09, -0.11, -0.12),
  lat = c(51.50, 51.52, 51.48),
  label = c("Point 1", "Point 2", "Point 3")
)

    Cette partie crée un data.frame contenant des coordonnées et des étiquettes pour trois points supplémentaires.

  2. Ajouter des marqueurs supplémentaires :

map <- map %>% 
  addMarkers(data = data, ~lng, ~lat, popup = ~label)

Ces lignes ajoutent des marqueurs supplémentaires à la carte en utilisant les données du data.frame créé précédemment. Chaque marqueur affiche le texte correspondant dans label lorsqu’on clique dessus.

  1. Afficher la carte :
map

Enfin, cette ligne affiche la carte créée, avec tous les marqueurs et modifications apportées.

VOici le code en intégralité :

# Installer et charger le package leaflet
if (!require(leaflet)) {
    install.packages("leaflet")
}
library(leaflet)

# Créer une carte de base
map <- leaflet() %>% 
  addTiles()  # Ajoute les tuiles de base d'OpenStreetMap

# Ajouter un marqueur
map <- map %>% 
  addMarkers(lng = -0.09, lat = 51.50, popup = "The marker is placed at London")

# Changer le fond de carte
map <- map %>% 
  addProviderTiles(providers$Stamen.TonerLite)

# Données pour les marqueurs supplémentaires
data <- data.frame(
  lng = c(-0.09, -0.11, -0.12),
  lat = c(51.50, 51.52, 51.48),
  label = c("Point 1", "Point 2", "Point 3")
)

# Ajouter des marqueurs supplémentaires
map <- map %>% 
  addMarkers(data = data, ~lng, ~lat, popup = ~label)

# Afficher la carte
map

Autres exemples

Paris

  1. Définition des Coordonnées de Paris :

    Paris <- c(2.351462,48.8567)

    Cette ligne crée un vecteur nommé Paris avec la longitude et la latitude de Paris, France.

  2. Création et Configuration de la Carte :

    m2 <- leaflet() %>% setView(lng = Paris[1], lat = Paris[2], zoom = 12) %>% 
  addTiles()

    Ici, une carte est créée avec leaflet() et la vue est centrée sur Paris avec un niveau de zoom de 12. Les tuiles de base (généralement d’OpenStreetMap) sont ajoutées avec addTiles().

  3. Modification du Style de la Carte :

    m2 %>% addProviderTiles("Stamen.Toner")

    Cette ligne change le style de la carte en utilisant la tuile Stamen.Toner, qui offre un design graphique distinct.

IA School Toulouse

content <- paste(sep = "<br/>",
  "<b><a href='https://www.intelligence-artificielle-school.com/ecole/nos-campus/toulouse/'>IA School - Toulouse</a></b>",
  "2 Bd de Strasbourg",
  "31000 Toulouse"
)

leaflet() %>% 
  addTiles() %>%
  addPopups(1.4485130539619018, 43.60676750775245, 
            content, options = popupOptions(closeButton = FALSE)
  )

  1. Création du Contenu du Popup :

    content <- paste(sep = "<br/>", ...)

    Cette portion crée une chaîne HTML content qui sera utilisée dans le popup. Elle contient un lien vers le site web de l’IA School à Toulouse, ainsi que l’adresse de l’école, formatée avec des balises HTML pour une meilleure présentation.

  2. Création et Configuration de la Carte avec Popup :

    leaflet() %>% 
  addTiles() %>%
  addPopups(...)

    Une nouvelle carte est créée, des tuiles de base sont ajoutées, et un popup est placé aux coordonnées spécifiées (Toulouse, France). Le popup affiche le contenu HTML défini précédemment. L’option closeButton = FALSE signifie que le popup n’aura pas de bouton de fermeture.

Dans les deux cas, ces blocs de code illustrent comment créer des cartes interactives en R avec le package leaflet, en se concentrant sur des emplacements spécifiques (Paris et Toulouse) et en utilisant des fonctionnalités telles que les vues personnalisées, les styles de tuiles et les popups.

Créer des graphiques dynamiques : plotly

Graphiques Interactifs avec Plotly en R**

Le package Plotly permet de créer des graphiques web interactifs de qualité publication.

La première chose à faire est d’installer et de charger le package Plotly avec :

# install.packages("plotly")
library(plotly)
## 
## Attaching package: 'plotly'
## The following object is masked from 'package:ggplot2':
## 
##     last_plot
## The following object is masked from 'package:stats':
## 
##     filter
## The following object is masked from 'package:graphics':
## 
##     layout

De plus, nous avons besoin de données pour travailler. Nous allons créer x, y et y3 avec des valeurs numériques pour les utiliser plus tard dans nos exemples.

x = c(1, 2, 3, 4, 5)
y = c(6, 7, 8, 9, 10)
y3 = c(-6, -7, -8, -9, -10)

Tracer une droite

La première chose à faire est d’appeler plot_ly(). Le premier argument est les données que nous voulons tracer (x & y), le second décrit le type de graphique, tandis que le troisième définit comment nos données seront affichées dans le graphique. Ici, nous voulons un graphique en ligne, donc nous choisissons “lines”. Regardez l’exemple ci-dessous.

plot_ly(
  x = c(1, 2, 3),
  y = c(4, 5, 6),
  type = "scatter",
  mode = "lines"
)

Nuage de Points

La première chose à faire est d’appeler plot_ly(). Ici, nous voulons un nuage de points, donc nous choisissons “markers”, qui est le choix par défaut, donc il peut être omis. Regardez l’exemple ci-dessous.

plot_ly(
  x = c(1, 2, 3),
  y = c(4, 5, 6),
  type = "scatter",
  mode = "markers"
)

Diagramme à Barres

La première chose à faire est d’appeler plot_ly(). Le premier argument est les données que nous voulons tracer (x & y), le second décrit le type de graphique, qui est maintenant un diagramme à barres.

plot_ly(
  x = c(1, 2, 3),
  y = c(4, 5, 6),
  type = "bar"
)

Jitter

La première chose à faire est d’appeler plot_ly(). Ici, nous voulons un graphique à bulles, donc nous choisissons “markers”. Ensuite, nous définissons la taille pour chaque point et enfin sa couleur. Regardez l’exemple ci-dessous.

plot_ly(
  x = c(1, 2, 3),
  y = c(4, 5, 6),
  type = "scatter",
  mode = "markers",
  size = c(2, 6, 9),
  marker = list(color = c("red", "black", "yellow"))
)
## Warning: `line.width` does not currently support multiple values.

Heatmap

La première chose à faire est d’appeler plot_ly(). Le premier argument est les données que nous voulons tracer, qui est l’ensemble de données “volcano” et sera donné comme une matrice numérique “z”, le second décrit le type de graphique, qui est maintenant une carte de chaleur. Regardez l’exemple ci-dessous.

plot_ly(
  z = volcano,
  type = "heatmap"
)

Aires

La première chose à faire est d’appeler plot_ly(). Ici, nous voulons un graphique en aires, donc nous choisissons “lines” en combinaison avec l’argument fill. Regardez l’exemple ci-dessous.

plot_ly(
  x = c(1, 2, 3),
  y = c(4, 5, 6),
  type = "scatter",
  mode = "lines",
  fill = "tozeroy"
)

Mise en Page

Améliorons maintenant la mise en page de notre graphique. D’abord, nous verrons comment ajouter une trace à cela. Nous le faisons si nous voulons séparer nos marqueurs en groupes. Regardez l’exemple ci-dessous, dans lequel le premier groupe a y > 0 et l’autre y < 0 :

df <- data.frame(
  x = c(1, 2, 3),
  y = c(4, 5, 6),
  y3 = c(-4, -5, -6)
)

df %>% 
plot_ly(
  type = "scatter",
  mode = "markers"
) %>%  
  add_trace(x = ~x, y = ~y3)

Nous pouvons également ajouter la trace comme une légende dans notre graphique, définir sa position précise et la colorer. Regardez l’exemple ci-dessous :

df %>% 
plot_ly(
  type = "scatter",
  mode = "markers"
) %>%
add_trace(x = ~x, y = ~y3) %>%
layout(
  legend = list(
    x = 1,
    y = 1,
    bgcolor = "yellow"
  )
)

La dernière chose que nous devrions être capables de faire lors de la création d’un graphique est de gérer les axes. D’abord, nous créons une liste qui contient toutes les caractéristiques des axes, puis nous attachons cette liste aux deux axes comme l’exemple ci-dessous :

library(tidyverse)
library(plotly)

# Création du 1er facteur "magFactor" qui catégorise la magnitude des séismes
quakes$magFactor <- factor(floor(quakes$mag))

# Création du second facteur "region" qui catégorise la région géographique des séismes (Est/Ouest)
quakes$region <- factor(quakes$long >= 175, labels = c("Ouest", "Est"))

head(quakes, n = 5)
##      lat   long depth mag stations magFactor region
## 1 -20.42 181.62   562 4.8       41         4    Est
## 2 -20.62 181.03   650 4.2       15         4    Est
## 3 -26.00 184.10    42 5.4       43         5    Est
## 4 -17.97 181.66   626 4.1       19         4    Est
## 5 -20.42 181.96   649 4.0       11         4    Est
plot_ly(x = quakes$mag, type = "histogram") %>% 
  layout(title = "Magnitude des séismes")
axe_x <- list(
  autotick = FALSE,              # pour contrôler le pas de l'axe des abscisses
  ticks = "outside",             # ou "inside"
  dtick = 20,                    # le nombre d'intervalles
  ticklen = 10,                  # la longueur des indicateurs
  tickwidth = 2,                 # la largeur des indicateurs
  tickcolor = toRGB("blue"),     # la couleur
  zeroline = TRUE,
  showline = TRUE,
  zerolinecolor = toRGB("red"),  # pour mettre en exergue la droite 'x = 0'
  zerolinewidth = 3,
  linecolor = toRGB("black"),
  linewidth = 2
  )
# axe_y <- list()   # On pourrait faire de même avec l'axe des ordonnées
plot_ly(alpha = 0.8, histnorm = "probability", xlim = c()) %>% 
  add_histogram(x = quakes$long, name = "Longitudes") %>% 
  add_histogram(x = quakes$stations, name = "Nombre de stations") %>%
  add_histogram(x = quakes$lat, name = "Latitudes") %>%
  layout(title = "Distribution empirique de trois variables décrivant les séismes", 
         barmode = "overlay", xaxis = axe_x)

Voici un exemple de script d’analyse complet :

# Chargement des bibliothèques nécessaires
library(plotly)
library(tidyverse)
library(lubridate)

# Configurer la graine aléatoire pour la reproductibilité
set.seed(123)

# Créer une séquence de dates (chaque mois de 2020)
dates <- seq(ymd("2020-01-01"), ymd("2020-12-31"), by="month")

# Codes d'état des États-Unis (exemple avec 5 états)
state_codes <- c("AL", "AK", "AZ", "AR", "CA")

# Générer des données aléatoires
num_rows <- length(dates) * length(state_codes)
df <- data.frame(
  time = rep(dates, each=length(state_codes)),
  state_code = rep(state_codes, times=length(dates)),
  num_colonies = sample(100:10000, num_rows, replace = TRUE),
  percent_lost = runif(num_rows, 0, 100),
  varroa_mites = runif(num_rows, 0, 100),
  other_pests = runif(num_rows, 0, 100),
  diseases = runif(num_rows, 0, 100),
  pesticides = runif(num_rows, 0, 100),
  other = runif(num_rows, 0, 100),
  unknown = runif(num_rows, 0, 100)
)

# Afficher les premières lignes du dataframe
head(df)
##         time state_code num_colonies percent_lost varroa_mites other_pests
## 1 2020-01-01         AL         2562     33.28235     35.39046   96.110479
## 2 2020-01-01         AK         2610     48.86130     64.99852   72.839443
## 3 2020-01-01         AZ         8817     95.44738     37.47140   68.637508
## 4 2020-01-01         AR         3085     48.29024     35.54454    5.284394
## 5 2020-01-01         CA         1941     89.03502     53.36879   39.522013
## 6 2020-02-01         AL         9433     91.44382     74.03344   47.784538
##    diseases pesticides    other  unknown
## 1 13.710608   11.94048 13.70675 43.61300
## 2 39.658459   52.60297 90.53096 46.40166
## 3 22.498533   22.50734 57.63018 16.52981
## 4  5.795856   48.64118 39.54489 58.49366
## 5 39.589269   37.02148 44.98025 27.07780
## 6  6.492830   98.33502 70.65019 23.00969
fig <- df %>%
       plot_ly() %>%
       add_trace(
         type = "choropleth",
         locations = ~state_code,
         locationmode = "USA-states",
         z = ~varroa_mites,
         colorscale = "Viridis_r",
         color = ~varroa_mites
       ) %>%
       layout(
         geo = list(scope = "usa"),
         frame = ~time
       )
fig
## Warning: 'layout' objects don't have these attributes: 'frame'
## Valid attributes include:
## '_deprecated', 'activeshape', 'annotations', 'autosize', 'autotypenumbers', 'calendar', 'clickmode', 'coloraxis', 'colorscale', 'colorway', 'computed', 'datarevision', 'dragmode', 'editrevision', 'editType', 'font', 'geo', 'grid', 'height', 'hidesources', 'hoverdistance', 'hoverlabel', 'hovermode', 'images', 'legend', 'mapbox', 'margin', 'meta', 'metasrc', 'modebar', 'newshape', 'paper_bgcolor', 'plot_bgcolor', 'polar', 'scene', 'selectdirection', 'selectionrevision', 'separators', 'shapes', 'showlegend', 'sliders', 'smith', 'spikedistance', 'template', 'ternary', 'title', 'transition', 'uirevision', 'uniformtext', 'updatemenus', 'width', 'xaxis', 'yaxis', 'barmode', 'bargap', 'mapType'

Mise en Page multiple

Pour faire une figure contenant plusieurs graphiques dans la même fenêtre, on doit utiliser la fonction subplot. Les principaux paramètres de cette dernière sont:

…: Une série de graphiques plotly ou ggplot2 nrows: Le nombre de rangés sur lesquelles distribuer les graphiques shareX/shareY: Partager l’axe X / Y

# Graphique 1
gg_quakes <- qplot(long, lat, data = quakes, color = region) + coord_quickmap()
## Warning: `qplot()` was deprecated in ggplot2 3.4.0.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
gg_quakes

# Nous avons produit un graphique ggplot classique, non-interactif. Pour le rendre interactif, il suffit d’appliquer la fonction ggplotly ainsi:
p_scatter <-  ggplotly(gg_quakes)


# Graphique 2 
p_box <- plot_ly(data = quakes[quakes$region == "Est",],
                 x = ~ mag, type = "box", name = "Est") %>%
  add_trace(data = quakes[quakes$region == "Ouest",], x = ~ mag, name = "Ouest")

# Multi-graphique :
subplot(p_scatter, p_box, nrows = 1, shareX = FALSE, shareY = FALSE, margin = 0.05) %>%
  layout(title = "Longitude, latitude et magnitude des tremblements de terre",
         xaxis = list(title = "Longitude"),
         yaxis = list(title = "Latitude", scaleanchor = "x"),
         xaxis2 = list(title = "Magnitude"))
## Warning: Can only have one: config

Pour en savoir plus : (data to viz)[https://www.data-to-viz.com/]

Exercices

Pour commencer à pratiquer, suivez ces étapes :

  1. Accédez au Dépôt GitHub : Visitez l’URL fournie : https://github.com/universdesdonnees/Introduction-a-R pour accéder au dépôt GitHub contenant les matériaux du cours.

  2. Trouvez le Fichier des Exercices : Dans le dépôt, localisez le fichier nommé exercices6.txt. Ce fichier contient les premiers exercices que vous devez pratiquer.

  3. Lisez et Essayez de Résoudre les Exercices : Ouvrez le fichier exercices6.txt et lisez attentivement les exercices. Essayez de les résoudre par vous-même dans votre environnement R (comme RStudio). Il est important de pratiquer par vous-même avant de regarder les solutions pour mieux apprendre.

  4. Consultez la Correction : Une fois que vous avez tenté de résoudre les exercices, ou si vous rencontrez des difficultés, consultez le fichier correction_exercices6.R pour voir les solutions. Analysez les solutions pour comprendre les méthodes et logiques utilisées.